Çift Yönlü Bağlı Listeler

Çift yönlü bağlı liste, bir veri yapısıdır ve tek yönlü bağlı listenin aksine, her bir düğümün bir önceki ve bir sonraki düğümle bağlantısı vardır. Bu nedenle çift yönlü bağlı liste, her iki yönde de ilerlenebilir.

Her bir düğüm, bir veri elemanı ve önceki ve sonraki düğümlere işaret eden iki işaretçi içerir. İlk düğümün önceki işaretçisi NULL'dır, son düğümün sonraki işaretçisi de NULL'dır.

Çift yönlü bağlı listeler, bazı durumlarda tek yönlü bağlı listelerden daha avantajlıdır. Örneğin, listede geriye doğru ilerleme gerektiren bir işlem varsa, çift yönlü bağlı liste kullanmak daha uygun olabilir. Ayrıca, çift yönlü bağlı listelerde, herhangi bir düğümün önceki veya sonraki düğüme erişimini kolaylaştıran bazı işlemler de daha kolaydır.

Çift yönlü bağlı listelerin dezavantajı ise, her bir düğümün iki işaretçi içermesi nedeniyle daha fazla bellek kullanımıdır. Ayrıca, listenin başına veya sonuna yeni bir düğüm eklemek için, her iki yönde de işaretçi değişiklikleri gerektiğinden, tek yönlü bağlı listelere göre daha fazla işlem gerekebilir.

Çift Yönlü Bağlı Liste Oluşturma

Aşağıda çift yönlü bağlı liste oluşturmak için C programlama kodu verilmiştir. Kod, kullanıcının bağlı liste boyutunu belirlemesine izin verir ve ardından kullanıcının bağlı liste elemanlarını girmesine izin verir. Bağlı liste, girdi sırasına göre oluşturulur ve ardından baştan sona ve sondan başa doğru yazdırılır.

#include <stdio.h>
#include <stdlib.h>

// Bağlı liste elemanları için düğüm yapısı
struct node {
   int data;
   struct node *next;
   struct node *prev;
};

int main() {
   int n, i;
   struct node *head, *new_node, *temp;

   // Bağlı liste boyutunu kullanıcıdan al
   printf("Bağlı liste boyutunu girin: ");
   scanf("%d", &n);

   // Bağlı liste için ilk elemanı oluştur
   head = NULL;
   temp = NULL;
   for(i = 0; i < n; i++) {
      new_node = (struct node*)malloc(sizeof(struct node));
      printf("Bağlı liste elemanını girin: ");
      scanf("%d", &new_node->data);
      new_node->next = NULL;
      new_node->prev = NULL;
      if(head == NULL) {
         head = new_node;
         temp = new_node;
      }
      else {
         temp->next = new_node;
         new_node->prev = temp;
         temp = new_node;
      }
   }

   // Bağlı liste elemanlarını baştan sona doğru yazdır
   printf("\nBaştan sona doğru bağlı liste elemanları: ");
   temp = head;
   while(temp != NULL) {
      printf("%d ", temp->data);
      temp = temp->next;
   }

   // Bağlı liste elemanlarını sondan başa doğru yazdır
   printf("\nSondan başa doğru bağlı liste elemanları: ");
   temp = head;
   while(temp->next != NULL) {
      temp = temp->next;
   }
   while(temp != NULL) {
      printf("%d ", temp->data);
      temp = temp->prev;
   }

   return 0;
}

Yukarıdaki kod, kullanıcı tarafından belirtilen boyutta bir çift yönlü bağlı liste oluşturur ve ardından baştan sona ve sondan başa doğru yazdırır. Kullanıcı, bağlı liste elemanlarını girerken kullanabilir. Bağlı liste oluşturma, elemanları ekleme, baştan sona ve sondan başa doğru yazdırma gibi işlemler için düğüm yapısı ve işlemler için gerekli diğer C fonksiyonları da eklenebilir.

Çift Yönlü Bağlı Listelerde Sona Eleman Ekleme

Çift yönlü bağlı listelerde sona eleman eklemek için aşağıdaki C kodunu kullanabilirsiniz:

#include <stdio.h>
#include <stdlib.h>

// Çift yönlü bağlı liste düğüm yapısı
struct node {
    int data;
    struct node* prev;
    struct node* next;
};

// Yeni bir düğüm oluşturmak için kullanılan fonksiyon
struct node* createNode(int data) {
    struct node* newNode = (struct node*)malloc(sizeof(struct node));
    newNode->data = data;
    newNode->prev = NULL;
    newNode->next = NULL;
    return newNode;
}

// Son elemana düğüm eklemek için kullanılan fonksiyon
void append(struct node** head_ref, int data) {
    struct node* new_node = createNode(data);

    if (*head_ref == NULL) {
        // Eğer liste boş ise yeni düğümü başa ekle
        *head_ref = new_node;
        return;
    }

    struct node* last = *head_ref;
    while (last->next != NULL) {
        // Listenin son düğümüne git
        last = last->next;
    }

    // Yeni düğümü sona ekle
    last->next = new_node;
    new_node->prev = last;
}

// Bağlı listenin elemanlarını yazdırmak için kullanılan fonksiyon
void printList(struct node* node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
}

int main() {
    struct node* head = NULL;

    // Elemanları listeye ekle
    append(&head, 10);
    append(&head, 20);
    append(&head, 30);
    append(&head, 40);

    printf("Liste: ");
    printList(head);

    return 0;
}

 Çift Yönlü Bağlı Listelerde Başa Eleman Ekleme

Aşağıdaki gibi çift yönlü bağlı listelerde başa eleman ekleme işlemini gerçekleştiren bir C kodu örneği verebiliriz:

#include <stdio.h>
#include <stdlib.h>

// Çift yönlü bağlı liste eleman yapısı
struct node {
    int data;
    struct node *prev;
    struct node *next;
};

// Başa eleman ekleme fonksiyonu
void insertAtBeginning(struct node **head_ref, int new_data) {
    // Yeni eleman için bellek ayrılıyor
    struct node *new_node = (struct node*)malloc(sizeof(struct node));
    new_node->data = new_data;
    
    // Yeni elemanın bağlantıları düzenleniyor
    new_node->prev = NULL;
    new_node->next = (*head_ref);
    
    // Listenin başlangıç düğümü değiştiriliyor
    if ((*head_ref) != NULL) {
        (*head_ref)->prev = new_node;
    }
    (*head_ref) = new_node;
}

// Liste elemanlarını yazdırma fonksiyonu
void printList(struct node *node) {
    while (node != NULL) {
        printf("%d ", node->data);
        node = node->next;
    }
}

// Test fonksiyonu
int main() {
    struct node *head = NULL;
    
    // Elemanlar başa eklendi
    insertAtBeginning(&head, 3);
    insertAtBeginning(&head, 2);
    insertAtBeginning(&head, 1);
    
    printf("Liste: ");
    printList(head);
    
    return 0;
}

Çift Yönlü Bağlı Listelerde Araya Eleman Ekleme

Aşağıdaki C kodu, çift yönlü bağlı listelerde belirtilen pozisyona bir eleman eklemek için kullanılabilir. Örnek olarak, yeni bir düğüm oluşturarak ve bu düğümü verilen konuma yerleştirerek işlem yapar.

#include <stdio.h>
#include <stdlib.h>

struct node {
    int data;
    struct node *prev;
    struct node *next;
};

void insertNode(struct node **head, int position, int value) {
    struct node *newNode, *temp;
    int i;

    newNode = (struct node *)malloc(sizeof(struct node));
    newNode->data = value;
    newNode->prev = NULL;
    newNode->next = NULL;

    if (*head == NULL) { // if list is empty
        *head = newNode;
        return;
    }

    if (position == 1) { // if inserting at the beginning
        newNode->next = *head;
        (*head)->prev = newNode;
        *head = newNode;
        return;
    }

    temp = *head;
    for (i = 1; i < position - 1 && temp != NULL; i++) {
        temp = temp->next;
    }

    if (temp == NULL) { // if position is greater than the size of the list
        printf("Position out of range\n");
        return;
    }

    newNode->next = temp->next;
    newNode->prev = temp;
    if (temp->next != NULL) {
        temp->next->prev = newNode;
    }
    temp->next = newNode;
}

void printList(struct node *head) {
    while (head != NULL) {
        printf("%d ", head->data);
        head = head->next;
    }
    printf("\n");
}

int main() {
    struct node *head = NULL;

    insertNode(&head, 1, 10); // insert at the beginning
    insertNode(&head, 2, 20); // insert at position 2
    insertNode(&head, 3, 30); // insert at position 3
    insertNode(&head, 2, 15); // insert at position 2
    insertNode(&head, 5, 50); // position out of range

    printf("List: ");
    printList(head);

    return 0;
}

Çift Yönlü Bağlı Listelerde Sondan Eleman Silme

Çift Yönlü Bağlı Listelerde Baştan Eleman Silme

Çift Yönlü Bağlı Listelerde Aradan Eleman Silme